5.5 Enumerationen (Aufzählungen)
 
Eine Enumeration ist als Gruppierung mehrerer Konstanten zu verstehen, die zur Laufzeit nicht verändert werden können. Alle in der Enumeration enthaltenen Konstanten sind grundsätzlich vom gleichen Datentyp. Dabei kann es sich um byte, short, int oder long handeln, andere CLS-kompatible Datentypen sind nicht zugelassen. Die Angabe des Typs einer Enumeration ist optional. Wird er nicht angegeben, handelt es sich um int-Elemente. Enumerationen sind von der gemeinsamen Basisklasse System.Enum abgeleitet.
Betrachten Sie das folgende Beispiel der Enumeration Spielkarte:
| public enum Spielkarte : long {
|
| Karo = 9,
|
| Herz = 10,
|
| Pik = 11,
|
| Kreuz = 12
|
| }
|
Eine Enumeration wird mit dem Schlüsselwort enum eingeleitet. Hinter der Angabe des Bezeichners kann optional der Datentyp aller in der Enumeration enthaltenen Konstanten angegeben werden. Dabei wird der Datentyp, im Beispiel handelt es sich um den Typ long, mit einem Doppelpunkt vom Bezeichner der Aufzählung getrennt.
Der enum-Block enthält alle erforderlichen Konstanten, die durch ein Komma getrennt werden. Der von ihnen vertretene Wert kann optional zugewiesen werden, ansonsten wird er nach einem bestimmten Algorithmus automatisch vergeben, wie unten noch erläutert wird.
Die Definition einer Enumeration darf an denselben Stellen im Programmcode erfolgen wie die einer Struktur, also
|
als eigenständiges Element in einer eigenen Quellcodedatei |
|
|
neben anderen Klassen-, Struktur- oder Enumerationsdefinitionen in derselben Quellcodedatei |
|
|
im Deklarationsabschnitt einer Klasse |
Innerhalb einer Methode ist die Definition einer Enumeration unzulässig. Wird eine Enumeration außerhalb einer Klasse definiert, beschreiben die Zugriffsmodifizierer public und internal die Sichtbarkeit, innerhalb einer Klasse kommen noch private und protected hinzu.
5.5.1 Wertzuweisung an enum-Mitglieder
Die Wertzuweisung an die enum-Elemente ist optional. Wird darauf verzichtet, steht das erste Element für den Wert 0, der sich mit jedem Folgeelement um +1 erhöht. Die Konstantenwerte können auch negativ sein. Beachten Sie, dass der Wert als Basis für die Nummerierung aller Folgeelemente benutzt wird:
| public enum TestEnum {
|
| a = –2,
|
| b,
|
| c
|
| }
|
Da das erste Element (a) für den Konstantenwert –2 steht, hat das Folgeelement (b) den Wert –1 und für das letzte (c) schließlich 0. Bei der Angabe der Konstantenwerte muss keine Reihenfolge eingehalten werden. Es dürfen sogar mehrere Elemente gleiche Werte aufweisen.
Eine enum-Aufzählung wird von der Common Language Runtime wie ein Wertetyp behandelt. Daher ist eine Variablendeklaration notwendig, um Nutzen aus einer Enumeration zu ziehen:
Die Variable myGame kann nun für ein beliebiges Element der Aufzählung stehen. Um welches es sich genau handelt, muss mit der Punktnotation angegeben werden:
| myGame = Spielkarte.Herz;
|
Eine andere Variante ist, einer beliebigen ganzzahligen Variablen den Wert einer auf einem enum-Typ basierenden Variablen zuweisen:
| Spielkarte myGame;
|
| myGame = myGame.Karo;
|
myGame wird in diesem Fall den Inhalt »Karo« aufweisen. Wenn Sie am Zahlenwert, der dieser Konstanten zugeordnet ist, interessiert sind, müssen Sie explizit konvertieren:
| long myGame = (long)Spielkarte.Karo;
|
5.5.2 Alle Mitglieder einer Aufzählung durchlaufen
Enumerationen werden uns im zweiten Teil dieses Buches, wenn wir uns der Programmierung von Windows-Anwendungen widmen, häufig begegnen. Dabei wird es manchmal sinnvoll sein, die Mitglieder einer Aufzählung in einer Schleife abzufangen. Ich möchte Ihnen am Beispiel der Aufzählung Spielkarte demonstrieren, wie das programmiertechnisch realisiert wird.
| // --------------------------------------------------------------
|
| // Beispiel: ...\Kapitel 5\Enumeration
|
| // --------------------------------------------------------------
|
| class Program {
|
| static void Main(string[] args) {
|
| foreach (Spielkarte karte in Enum.GetValues(typeof(Spielkarte)))
|
| Console.WriteLine(karte.ToString());
|
| Console.ReadLine();
|
| }
|
| }
|
| public enum Spielkarte : long {
|
| Karo = 9,
|
| Herz = 10,
|
| Pik = 11,
|
| Kreuz = 12
|
| }
|
| }
|
Wir können in solchen Fällen nicht mit einer herkömmlichen for-Schleife operieren, sondern müssen dazu die foreach-Schleife benutzen, die ein Array elementweise durchläuft und deren allgemeine Syntax lautet:
| foreach (Datentyp variable in Ausdruck) {...}
|
Zuerst wird eine Variable deklariert, deren Lebensdauer sich auf die Ausführung der Schleife beschränkt. Der Datentyp entspricht dem Datentyp der Konstanten in der Enumeration, deren Mitglieder wir in Erfahrung bringen wollen. Ausdruck ist das Array, das in der Schleife elementweise durchlaufen wird. Dieses Array müssen wir uns noch besorgen.
Eingangs wurde bereits erwähnt, dass alle Enumerationen aus der Klasse Enum abgeleitet werden. Diese stellt mit GetValues eine statische Methode zur Verfügung, die uns eine Array-Referenz aller in der Aufzählung enthaltenen Konstanten zurückliefert. GetValues ist wie folgt definiert:
| public static Array GetValues(Type enumType);
|
Der Rückgabewert ist vom Typ Array, das Übergabeargument vom Typ Type. Dieser Typ liefert Informationen über einen Datentyp, beispielsweise über die von einer Klasse veröffentlichten Methoden und Felder. Dazu müssen wir uns nur den beschreibenden Type eines bestimmten Datentyps besorgen. Hier hilft die C#-spezifische Funktion typeof weiter, der wir als Argument den Typbezeichner übergeben. Der Ausdruck
| Enum.GetValues(typeof(Spielkarte)))
|
liefert die Elemente der Enumeration als Array, das wir mit karte vom ersten bis zum letzten Element durchlaufen. Bei jedem Schleifendurchlauf zeigt karte auf eine andere Konstante, deren Namen wir an der Konsole ausgeben lassen. |
